package com.redlight.base;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.SystemUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.UUID;
import java.util.regex.Matcher;

/**
 * Created by chao on 2019/1/9.
 */
public class FileUtil extends FileUtils {
    private static Logger log = LoggerFactory.getLogger(FileUtil.class);

    public FileUtil() {
    }

    public static String getFileExt(String fileName) {
        String ext = "";
        if(null != fileName && 1 < fileName.length()) {
            int i = fileName.lastIndexOf(".");
            if(i != -1) {
                ext = fileName.substring(i + 1, fileName.length());
            }
        }

        return ext.toLowerCase();
    }

//    public static boolean copyFile(String srcFileName, String descFileName) {
//        return copyFileCover(srcFileName, descFileName, false);
//    }

//    public static boolean copyFileCover(String srcFileName, String descFileName, boolean coverlay) {
//        File srcFile = new File(srcFileName);
//        if(!srcFile.exists()) {
//            log.debug("复制文件失败，源文件 " + srcFileName + " 不存在!");
//            return false;
//        } else if(!srcFile.isFile()) {
//            log.debug("复制文件失败，" + srcFileName + " 不是一个文件!");
//            return false;
//        } else {
//            File descFile = new File(descFileName);
//            if(descFile.exists()) {
//                if(!coverlay) {
//                    log.debug("复制文件失败，目标文件 " + descFileName + " 已存在!");
//                    return false;
//                }
//
//                log.debug("目标文件已存在，准备删除!");
//                if(!delFile(descFileName)) {
//                    log.debug("删除目标文件 " + descFileName + " 失败!");
//                    return false;
//                }
//            } else if(!descFile.getParentFile().exists()) {
//                log.debug("目标文件所在的目录不存在，创建目录!");
//                if(!descFile.getParentFile().mkdirs()) {
//                    log.debug("创建目标文件所在的目录失败!");
//                    return false;
//                }
//            }
//
//            int readByte = false;
//            InputStream ins = null;
//            FileOutputStream outs = null;
//
//            boolean var9;
//            try {
//                ins = new FileInputStream(srcFile);
//                outs = new FileOutputStream(descFile);
//                byte[] buf = new byte[1024];
//
//                int readByte;
//                while((readByte = ins.read(buf)) != -1) {
//                    outs.write(buf, 0, readByte);
//                }
//
//                log.debug("复制单个文件 " + srcFileName + " 到" + descFileName + "成功!");
//                var9 = true;
//                return var9;
//            } catch (Exception var23) {
//                log.debug("复制文件失败：" + var23.getMessage());
//                var9 = false;
//            } finally {
//                if(outs != null) {
//                    try {
//                        outs.close();
//                    } catch (IOException var22) {
//                        var22.printStackTrace();
//                    }
//                }
//
//                if(ins != null) {
//                    try {
//                        ins.close();
//                    } catch (IOException var21) {
//                        var21.printStackTrace();
//                    }
//                }
//
//            }
//
//            return var9;
//        }
//    }

//    public static boolean copyDirectory(String srcDirName, String descDirName) {
//        return copyDirectoryCover(srcDirName, descDirName, false);
//    }

//    public static boolean copyDirectoryCover(String srcDirName, String descDirName, boolean coverlay) {
//        File srcDir = new File(srcDirName);
//        if(!srcDir.exists()) {
//            log.debug("复制目录失败，源目录 " + srcDirName + " 不存在!");
//            return false;
//        } else if(!srcDir.isDirectory()) {
//            log.debug("复制目录失败，" + srcDirName + " 不是一个目录!");
//            return false;
//        } else {
//            String descDirNames = descDirName;
//            if(!descDirName.endsWith(File.separator)) {
//                descDirNames = descDirName + File.separator;
//            }
//
//            File descDir = new File(descDirNames);
//            if(descDir.exists()) {
//                if(!coverlay) {
//                    log.debug("目标目录复制失败，目标目录 " + descDirNames + " 已存在!");
//                    return false;
//                }
//
//                log.debug("目标目录已存在，准备删除!");
//                if(!delFile(descDirNames)) {
//                    log.debug("删除目录 " + descDirNames + " 失败!");
//                    return false;
//                }
//            } else {
//                log.debug("目标目录不存在，准备创建!");
//                if(!descDir.mkdirs()) {
//                    log.debug("创建目标目录失败!");
//                    return false;
//                }
//            }
//
//            boolean flag = true;
//            File[] files = srcDir.listFiles();
//
//            for(int i = 0; i < files.length; ++i) {
//                if(files[i].isFile()) {
//                    flag = copyFile(files[i].getAbsolutePath(), descDirName + files[i].getName());
//                    if(!flag) {
//                        break;
//                    }
//                }
//
//                if(files[i].isDirectory()) {
//                    flag = copyDirectory(files[i].getAbsolutePath(), descDirName + files[i].getName());
//                    if(!flag) {
//                        break;
//                    }
//                }
//            }
//
//            if(!flag) {
//                log.debug("复制目录 " + srcDirName + " 到 " + descDirName + " 失败!");
//                return false;
//            } else {
//                log.debug("复制目录 " + srcDirName + " 到 " + descDirName + " 成功!");
//                return true;
//            }
//        }
//    }

    public static boolean delFile(String fileName) {
        File file = new File(fileName);
        if(!file.exists()) {
            log.debug(fileName + " 文件不存在!");
            return true;
        } else {
            return file.isFile()?deleteFile(fileName):deleteDirectory(fileName);
        }
    }

    public static boolean deleteFile(String fileName) {
        File file = new File(fileName);
        if(file.exists() && file.isFile()) {
            if(file.delete()) {
                log.debug("删除文件 " + fileName + " 成功!");
                return true;
            } else {
                log.debug("删除文件 " + fileName + " 失败!");
                return false;
            }
        } else {
            log.debug(fileName + " 文件不存在!");
            return true;
        }
    }

    public static boolean deleteDirectory(String dirName) {
        String dirNames = dirName;
        if(!dirName.endsWith(File.separator)) {
            dirNames = dirName + File.separator;
        }

        File dirFile = new File(dirNames);
        if(dirFile.exists() && dirFile.isDirectory()) {
            boolean flag = true;
            File[] files = dirFile.listFiles();

            for(int i = 0; i < files.length; ++i) {
                if(files[i].isFile()) {
                    flag = deleteFile(files[i].getAbsolutePath());
                    if(!flag) {
                        break;
                    }
                } else if(files[i].isDirectory()) {
                    flag = deleteDirectory(files[i].getAbsolutePath());
                    if(!flag) {
                        break;
                    }
                }
            }

            if(!flag) {
                log.debug("删除目录失败!");
                return false;
            } else if(dirFile.delete()) {
                log.debug("删除目录 " + dirName + " 成功!");
                return true;
            } else {
                log.debug("删除目录 " + dirName + " 失败!");
                return false;
            }
        } else {
            log.debug(dirNames + " 目录不存在!");
            return true;
        }
    }

    public static boolean createFile(String descFileName) {
        File file = new File(descFileName);
        if(file.exists()) {
            log.debug("文件 " + descFileName + " 已存在!");
            return false;
        } else if(descFileName.endsWith(File.separator)) {
            log.debug(descFileName + " 为目录，不能创建目录!");
            return false;
        } else if(!file.getParentFile().exists() && !file.getParentFile().mkdirs()) {
            log.debug("创建文件所在的目录失败!");
            return false;
        } else {
            try {
                if(file.createNewFile()) {
                    log.debug(descFileName + " 文件创建成功!");
                    return true;
                } else {
                    log.debug(descFileName + " 文件创建失败!");
                    return false;
                }
            } catch (Exception var3) {
                var3.printStackTrace();
                log.debug(descFileName + " 文件创建失败!");
                return false;
            }
        }
    }

    public static boolean createDirectory(String descDirName) {
        descDirName = descDirName.replaceAll(Matcher.quoteReplacement("\\"), "/");
        if(descDirName.indexOf(".") > 0) {
            descDirName = descDirName.substring(0, descDirName.lastIndexOf("/"));
        }

        String descDirNames = descDirName;
        if(!descDirName.endsWith(File.separator)) {
            descDirNames = descDirName + File.separator;
        }

        File descDir = new File(descDirNames);
        if(descDir.exists()) {
            log.debug("目录 " + descDirNames + " 已存在!");
            return false;
        } else if(descDir.mkdirs()) {
            log.debug("目录 " + descDirNames + " 创建成功!");
            return true;
        } else {
            log.debug("目录 " + descDirNames + " 创建失败!");
            return false;
        }
    }

    public static String getFilePathByOS(String filePath) {
        if(!SystemUtils.IS_OS_WINDOWS && filePath.charAt(1) == 58) {
            filePath = "/opt" + filePath.substring(2).replaceAll("\\\\", "/");
        }

        return filePath;
    }

    public static void writeToFile(String fileName, String content, boolean append) {
        writeToFile(fileName, content, "utf-8", append);
    }

    public static void writeToFile(String fileName, String content, String encoding, boolean append) {
        try {
            write(new File(fileName), content, encoding, append);
            log.debug("文件 " + fileName + " 写入成功!");
        } catch (IOException var5) {
            log.debug("文件 " + fileName + " 写入失败! " + var5.getMessage());
        }

    }

    public static void writeToFile(String fileName, byte[] data) throws Exception {
        createDirectory(fileName);
        OutputStream output = new FileOutputStream(fileName);
        IOUtils.write(data, output);
    }

    public static void writeToFileAsyn(String fileName, String content, String encoding, boolean append) {
        (new Thread(() -> {
            try {
                write(new File(fileName), content, encoding, append);
                log.debug("文件 " + fileName + " 异步写入成功!");
            } catch (IOException var5) {
                log.debug("文件 " + fileName + " 异步写入失败! " + var5.getMessage());
            }

        })).start();
    }

//    public static void zipFilesToZipFile(String dirPath, File file, ZipOutputStream zouts) {
//        FileInputStream fin = null;
//        ZipEntry entry = null;
//        byte[] buf = new byte[4096];
//        int readByte = false;
//        if(file.isFile()) {
//            try {
//                fin = new FileInputStream(file);
//                entry = new ZipEntry(getEntryName(dirPath, file));
//                zouts.putNextEntry(entry);
//
//                int readByte;
//                while((readByte = fin.read(buf)) != -1) {
//                    zouts.write(buf, 0, readByte);
//                }
//
//                zouts.closeEntry();
//                fin.close();
//                System.out.println("添加文件 " + file.getAbsolutePath() + " 到zip文件中!");
//            } catch (Exception var8) {
//                var8.printStackTrace();
//            }
//        }
//
//    }

    private static String getEntryName(String dirPath, File file) {
        String dirPaths = dirPath;
        if(!dirPath.endsWith(File.separator)) {
            dirPaths = dirPath + File.separator;
        }

        String filePath = file.getAbsolutePath();
        if(file.isDirectory()) {
            filePath = filePath + "/";
        }

        int index = filePath.indexOf(dirPaths);
        return filePath.substring(index + dirPaths.length());
    }

    public static String getUUIDFileName(String fileName) {
        String uuid = UUID.randomUUID().toString();
        int position = fileName.lastIndexOf(".");
        String extension = fileName.substring(position);
        return uuid.replaceAll("-", "") + extension;
    }

//    public static boolean createFileToDisk(String filePath, InputStream inputStream) {
//        try {
//            if(null != filePath && !"".equals(filePath)) {
//                int bytesum = 0;
//                int byteread = false;
//                delFile(filePath);
//                if(null == inputStream) {
//                    log.error("新建" + filePath + "文件操作出错，错误原因：文件内容为null！");
//                    return false;
//                } else {
//                    createDir(filePath);
//                    FileOutputStream fs = new FileOutputStream(filePath);
//                    byte[] buffer = new byte[1444];
//
//                    int byteread;
//                    while((byteread = inputStream.read(buffer)) != -1) {
//                        bytesum += byteread;
//                        fs.write(buffer, 0, byteread);
//                    }
//
//                    fs.flush();
//                    fs.close();
//                    inputStream.close();
//                    return true;
//                }
//            } else {
//                log.error("新建文件操作出错，错误原因：文件路径和文件名称为空！");
//                return false;
//            }
//        } catch (Exception var6) {
//            log.error("新建" + filePath + "文件操作出错，错误原因：\r" + var6.getMessage());
//            var6.printStackTrace();
//            return false;
//        }
//    }

    public static boolean createDir(String path) {
        if(path != null && 0 < path.length()) {
            File file = new File(path);
            return file.isDirectory()?file.mkdirs():file.getParentFile().mkdirs();
        } else {
            return false;
        }
    }
}
